package cn.share.life.module.images.utils.flowFile;

import cn.hutool.core.io.FileUtil;
import cn.hutool.poi.excel.ExcelUtil;
import cn.hutool.poi.excel.ExcelWriter;
import cn.share.life.common.util.StringUtils;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.FilenameUtils;

import java.io.File;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class FlowFileMain2 {
    private static final String basePath = "E:/kuaqu2/";

    public static void main(String[] args) {
//        String specialProject = "鲁固直流";
//        String excelPath = "F:/公司3/2.2024年专项工程定价成本监审调查表-青豫直流0227.xlsx"; // Excel 文件路径
//        String fileNameMappingPath = "F:/公司3/28扎青-文件目录及文号V0.3.xlsx"; // 文件名映射路径
//        createExcelByLineDataPath(specialProject, excelPath, fileNameMappingPath);

//        String specialProject = "盂县送出";
//        String excelPath = "F:/公司3/0.监审表调整格式-0306-监审报表/2024年专项工程定价成本监审调查表-盂县送出0113.xlsx"; // Excel 文件路径
//        String fileNameMappingPath = "F:/公司3/3.盂县送出-文件目录及文号V0.1.xlsx"; // 文件名映射路径
//        createExcelByLineDataPath(specialProject, excelPath, fileNameMappingPath);

//        specialProject = "天中直流";
//        excelPath = "F:/公司3/0.监审表调整格式-0306-监审报表/2024年专项工程定价成本监审调查表-哈郑直流250218.xlsx"; // Excel 文件路径
//        fileNameMappingPath = "F:/公司3/1.哈郑直流（天中直流）-文件目录及文号V0.2.xlsx"; // 文件名映射路径
//        createExcelByLineDataPath(specialProject, excelPath, fileNameMappingPath);

        String specialProject = "德宝直流";
        String excelPath = "F:/公司3/0.监审表调整格式-0306-监审报表/2.2024年专项工程定价成本监审调查表-德宝直流0227.xlsx"; // Excel 文件路径
        String fileNameMappingPath = "F:/公司3/7.德宝直流-文件目录及文号V0.1.xlsx"; // 文件名映射路径
        String mappingPath = "F:/公司3/结算单与专项工程的映射关系V0.1.xlsx";
        createExcelByLineDataPath(specialProject, excelPath, fileNameMappingPath, mappingPath);
    }

    private static void createExcelByLineDataPath(String specialProject, String excelPath, String fileNameMappingPath, String mappingPath) {
        // 获取 2.2024年专项工程定价成本监审调查表
        List<ProjectEntity> projectEntityList = getProjectEntityList(excelPath);
        // 映射关系
        Map<String, String> projectMappingMap = getProjectMappingMap(mappingPath);

        // 获取文件名映射
        Map<String, FileMapping> projectFileMappingMap = Maps.newConcurrentMap();
        Map<String, FileMapping> unProjectFileMappingMap = Maps.newConcurrentMap();
        List<String> numberRegexList = getFileMapping(fileNameMappingPath, projectFileMappingMap, unProjectFileMappingMap);

        List<ItemEntity> projectItemEntityList = getProjectItemEntityList(specialProject, projectFileMappingMap, projectEntityList, numberRegexList, projectMappingMap);
        List<ItemEntity> unProjectItemEntityList = getUnProjectItemEntityList(specialProject, unProjectFileMappingMap, numberRegexList, projectMappingMap);

        writeExcel(projectItemEntityList, specialProject);
        writeExcel(unProjectItemEntityList, specialProject);
    }

    private static Map<String, String> getProjectMappingMap(String mappingPath) {
        List<List<Object>> listList = ExcelUtil.getReader(new File(mappingPath)).read(1);
        Map<String, String> projectMappingMap = Maps.newHashMap();
        for (List<Object> list : listList) {
            if (CollectionUtils.isEmpty(list) || list.size() < 2) {
                continue; // 跳过空行或列数不足的行
            }
            String key = String.valueOf(list.get(0)).trim();
            String value = String.valueOf(list.get(1)).trim();
            if (StringUtils.isNotEmpty(key) && StringUtils.isNotEmpty(value)) {
                projectMappingMap.put(key, value);
            }
        }
        return projectMappingMap;
    }

    private static List<ItemEntity> getUnProjectItemEntityList(String flowName, Map<String, FileMapping> unProjectFileMappingMap,
                                                               List<String> numberRegexList, Map<String, String> projectMappingMap) {
        List<ItemEntity> unProjectItemEntityList = Lists.newArrayList();
        for (Map.Entry<String, FileMapping> entry : unProjectFileMappingMap.entrySet()) {
            String key = entry.getKey();
            FileMapping fileMapping = entry.getValue();

            File file = new File(basePath + key.replace("\\", "/"));
            String path = file.getPath();
            path = path.replace("\\", "/"); // 替换为正斜杠

            String name = FilenameUtils.getName(key);
            // 这里可以添加一些测试代码来验证 ItemEntity 类的功能
            ItemEntity item = new ItemEntity();
            item.setFileOriginalName(name);
            item.setFileName(removeStrNumberAndPoint(name).trim());  // 文件名称

            // 文件名字中包含的，xxxx11号，有固定规则
            String fileNumber = NumberEnums.getNumber(name, numberRegexList);
            item.setFileNumber(fileNumber);
            // 专项工程
            item.setSpecialProject(flowName);
            item.setFileName(removeSpecialCharacters(item.getFileName()).replace(fileNumber, "").trim());

            if (file.exists()) {
                item.setFileSize(file.length() + "");
            }
            item.setFileType(FileUtil.getSuffix(name).toLowerCase());
            item.setOfflineFileDirectory(path.replace(basePath, "").replace("/", "\\"));

            // 标准文件库类型对应的线下文件目录
            String standardFileType = fileMapping.getStandardFileType();
            item.setStandardFileType(standardFileType);
            // 根据地区判断 -- 专项工程
            item.setSpecialProject(LineMappingEnums.getValueByKey(name, flowName, standardFileType));
            // 标准文件库类型（名字必须标准）
            item.setStandardFileDirectory(fileMapping.getStandardFileDirectory());

            // 根据地区判断 -- 专项工程
//            if (!item.getSpecialProject().equals("-")) {
//                String areaByFlowName = checkByArea(name, flowName, lineAreaList);
//                item.setSpecialProject(areaByFlowName);
//            }

            item.setDataType(ProjectTypeEnums.getType(fileMapping.getStandardFileType()));
            String yearByFlowName = getYearByFlowName(name);
            if (StringUtils.isNotEmpty(yearByFlowName)) {
                item.setYear(yearByFlowName);
            } else {
                item.setYear(getYearByFlowName(file.getParentFile().getName()));
            }
            item.setCustomDirectorySuggestion("");// 空
            unProjectItemEntityList.add(item);
        }
        return unProjectItemEntityList;
    }

    private static List<ItemEntity> getProjectItemEntityList(String flowName, Map<String, FileMapping> projectFileMappingMap,
                                                             List<ProjectEntity> projectEntityList, List<String> numberRegexList,
                                                             Map<String, String> projectMappingMap) {
        List<ItemEntity> projectItemEntityList = Lists.newArrayList();
        for (Map.Entry<String, FileMapping> entry : projectFileMappingMap.entrySet()) {
            String key = entry.getKey();
            FileMapping fileMapping = entry.getValue();

            File file = new File(basePath + key.replace("\\", "/"));
            String path = file.getPath();
            path = path.replace("\\", "/"); // 替换为正斜杠

            String name = FilenameUtils.getName(key);
            String baseName = FilenameUtils.getBaseName(name);
            // 这里可以添加一些测试代码来验证 ItemEntity 类的功能
            ItemEntity item = new ItemEntity();
            item.setFileOriginalName(name);
            item.setFileName(removeStrNumberAndPoint(name).trim());  // 文件名称

            // 文件名字中包含的，xxxx11号，有固定规则
            String fileNumber = NumberEnums.getNumber(name, numberRegexList);
            item.setFileNumber(fileNumber);
            // 专项工程
            item.setSpecialProject(flowName);
            if (!baseName.equals(fileNumber)) {
                // 如果文件名和文件号不同，则将文件名设置为去除文件号后的名称
                item.setFileName(item.getFileName().replace(fileNumber, "").replace("　", "").trim());
            }

            if (file.exists()) {
                item.setFileSize(file.length() + "");
            }
            item.setFileType(FileUtil.getSuffix(name).toLowerCase());
            item.setOfflineFileDirectory(path.replace(basePath, "").replace("/", "\\"));

            // 标准文件库类型对应的线下文件目录
            String standardFileType = fileMapping.getStandardFileType();
            item.setStandardFileType(standardFileType);
            // 根据地区判断
            item.setSpecialProject(LineMappingEnums.getValueByKey(name, flowName, standardFileType));
            // 标准文件库类型（名字必须标准）
            item.setStandardFileDirectory(fileMapping.getStandardFileDirectory());

            // 根据地区判断 -- 专项工程
//            if (!item.getSpecialProject().equals("-")) {
//                String areaByFlowName = checkByArea(name, flowName, lineAreaList);
//                item.setSpecialProject(areaByFlowName);
//            }

            item.setDataType(ProjectTypeEnums.getType(fileMapping.getStandardFileType()));
            item.setParentProjectName("");

            // 后续投资/竣工决算报告
            // 后续投资中竣工决算报告，用3.2项目名去遍历文件名，如果包含，则匹配项目名称。
            if (standardFileType.equals("后续投资/竣工决算报告")) {
                System.out.println("-----------------后续投资/竣工决算报告-----------------");
                List<ProjectEntity> projectList = projectEntityList.stream().filter(p -> dataMatching(item.getFileName(), p.getProjectName(), ""))
                        .collect(Collectors.toList());
                projectList = projectList.stream().sorted(Comparator.comparing(ProjectEntity::getCommissioningDate)).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(projectList)) {
                    // 如果有多个项目名称，则用英文逗号拼接
                    String projectName = projectList.stream().map(ProjectEntity::getProjectName).distinct().collect(Collectors.joining(","));
                    String projectYear = projectList.stream().map(ProjectEntity::getCommissioningDate).distinct().collect(Collectors.joining(","));
                    item.setProjectName(projectName);
                    item.setProjectYear(projectYear);
                } else {
                    // 如果没有匹配的项目名称，则设置为空
                    item.setProjectName("");
                    item.setProjectYear("");
                }
            } else if (standardFileType.equals("后续投资/决算审核报告")) {
                // 后续投资中决算审核报告，用文号匹配3.2项目名称，同时用文件名匹配项目名称，多个项目名称英文分隔符拼接。
                // 同一个文件匹配的项目进行去重处理
                System.out.println("-----------------后续投资/决算审核报告-----------------");
                List<ProjectEntity> projectList = projectEntityList.stream().filter(p -> dataMatching(p.getProjectName(), item.getFileNumber(),
                        FilenameUtils.getBaseName(item.getFileName()))).collect(Collectors.toList());
                projectList = projectList.stream().sorted(Comparator.comparing(ProjectEntity::getCommissioningDate)).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(projectList)) {
                    // 如果有多个项目名称，则用英文逗号拼接
                    String projectName = projectList.stream().map(ProjectEntity::getProjectName).distinct().collect(Collectors.joining(","));
                    String projectYear = projectList.stream().map(ProjectEntity::getCommissioningDate).distinct().collect(Collectors.joining(","));
                    item.setProjectName(projectName);
                    item.setProjectYear(projectYear);
                } else {
                    // 如果没有匹配的项目名称，则设置为空
                    item.setProjectName("");
                    item.setProjectYear("");
                }
            } else {
                Map<String, List<ProjectEntity>> projectDataMap = projectEntityList.stream().collect(Collectors.groupingBy(ProjectEntity::getDataSource));
                Map<String, String> projectMap = getProjectInfo(item.getFileName(), projectDataMap, fileNumber);
                item.setProjectName(projectMap.getOrDefault("projectName", ""));
                item.setProjectYear(projectMap.getOrDefault("projectYear", ""));
            }
            projectItemEntityList.add(item);
        }
        return projectItemEntityList;
    }

    public static boolean dataMatching(String src, String like1, String like2) {
        if (StringUtils.isEmpty(src) || StringUtils.isEmpty(like1) || StringUtils.isEmpty(like2)) {
            return false;
        }
        // 出去特殊字符，包含 - _ 空格 括号（中小大）
        src = src.replace("-", "").replace("_", "").replace(" ", "")
                .replace("（", "").replace("）", "").replace("(", "")
                .replace(")", "").replace("[", "").replace("]", "")
                .replace("{", "").replace("}", "");
        like1 = like1.replace("-", "").replace("_", "").replace(" ", "")
                .replace("（", "").replace("）", "").replace("(", "")
                .replace(")", "").replace("[", "").replace("]", "")
                .replace("{", "").replace("}", "");
        like2 = like2.replace("-", "").replace("_", "").replace(" ", "")
                .replace("（", "").replace("）", "").replace("(", "")
                .replace(")", "").replace("[", "").replace("]", "")
                .replace("{", "").replace("}", "");
        return src.contains(like1) && src.contains(like2);
    }

    private static List<String> getFileMapping(String fileNameMappingPath, Map<String, FileMapping> projectFileMappingMap,
                                                           Map<String, FileMapping> unProjectFileMappingMap) {
        List<List<Object>> projectList = ExcelUtil.getReader(new File(fileNameMappingPath), "专项工程_工程项目类").read(1);
        List<List<Object>> unProjectList = ExcelUtil.getReader(new File(fileNameMappingPath), "专项工程_非工程项目类").read(1);
        List<List<Object>> lineList = ExcelUtil.getReader(new File(fileNameMappingPath), "文号").read(1);

        // 工程类
        for (List<Object> row : projectList) {
            FileMapping fileMapping = new FileMapping();
            String path = String.valueOf(row.get(0));
            if (StringUtils.isEmpty(path)) {
                continue; // 跳过空路径
            }
            fileMapping.setOfflineFileDirectory(path);
            fileMapping.setStandardFileDirectory(String.valueOf(row.get(2)));
            fileMapping.setStandardFileType(String.valueOf(row.get(1)));
            projectFileMappingMap.put(fileMapping.getOfflineFileDirectory(), fileMapping);
        }
        // 非工程类
        for (List<Object> row : unProjectList) {
            FileMapping fileMapping = new FileMapping();
            String path = String.valueOf(row.get(0));
            if (StringUtils.isEmpty(path)) {
                continue; // 跳过空路径
            }
            fileMapping.setOfflineFileDirectory(path);
            fileMapping.setStandardFileDirectory(String.valueOf(row.get(2)));
            fileMapping.setStandardFileType(String.valueOf(row.get(1)));
            unProjectFileMappingMap.put(fileMapping.getOfflineFileDirectory(), fileMapping);
        }

        // 文号
        List<String> numberRegexList = Lists.newArrayList();
        for (List<Object> row : lineList) {
            numberRegexList.add(String.valueOf(row.get(0)));
        }
        return numberRegexList;
    }

    private static Map<String, String> getProjectInfo(String name, Map<String, List<ProjectEntity>> projectDataMap, String number) {
        Map<String, String> result = Maps.newHashMap();
        // 去掉文件后缀
        name = FilenameUtils.getBaseName(name);
        for (Map.Entry<String, List<ProjectEntity>> entry : projectDataMap.entrySet()) {
            String key = entry.getKey();
            List<ProjectEntity> projectEntities = entry.getValue();
            projectEntities = projectEntities.stream().sorted(Comparator.comparing(ProjectEntity::getCommissioningDate)).collect(Collectors.toList());

            // 去掉中文括号和英文括号再比较
            key = key.replace("(", "（").replace(")", "）");
            number = number.replace("(", "（").replace(")", "）");
            name = name.replace("(", "（").replace(")", "）");
            if (name.endsWith("（盖章）")) {
                name = name.replace("（盖章）", ""); // 去掉“盖章”后缀
            }

            if (StringUtils.isNotEmpty(number) && key.contains(number) && key.contains(name)) {
                result.put("projectName", projectEntities.stream().map(ProjectEntity::getProjectName).distinct().collect(Collectors.joining(",")));
                result.put("projectYear", projectEntities.stream().map(ProjectEntity::getCommissioningDate).distinct().collect(Collectors.joining(",")));
                return result;
            }

            if (StringUtils.isNotEmpty(number) && key.contains(number)) {
                // 则从拆分出的文件名称中提取括号后缀内的‘国网??’作为关键字，若在报表3-2的项目名称中存在
                List<String> areaByFlowName = getAreaByFlowName(name);
                areaByFlowName = areaByFlowName.stream().filter(f ->f.contains("国网")).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(areaByFlowName)) {
                    continue; // 如果没有地区信息，则跳过
                }
                String likeProjectName = areaByFlowName.get(0);
                likeProjectName = getText(likeProjectName);
                System.out.println("likeProjectName: " + likeProjectName);

                String finalLikeProjectName = likeProjectName;
                List<ProjectEntity> list = projectEntities.stream().filter(f -> f.getProjectName().contains(finalLikeProjectName)).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(list)) {
                    System.out.println("没有匹配的项目名称: " + likeProjectName);
                    continue; // 如果没有匹配的项目名称，则跳过
                }
                list = list.stream().sorted(Comparator.comparing(ProjectEntity::getCommissioningDate)).collect(Collectors.toList());
                result.put("projectName", list.stream().map(ProjectEntity::getProjectName).distinct().collect(Collectors.joining(",")));
                result.put("projectYear", list.stream().map(ProjectEntity::getCommissioningDate).distinct().collect(Collectors.joining(",")));
                return result;
            }
        }
        return result;
    }

    private static void writeExcel(List<ItemEntity> itemEntityList, String specialProject) {

        if (CollectionUtils.isEmpty(itemEntityList)) {
            System.out.println("没有数据可写入 Excel");
            return;
        }
        String dataType = itemEntityList.get(0).getDataType();

        List<List<String>> rows = Lists.newArrayList();
        List<String> header = Lists.newArrayList("序号", "文件原名", "文件名", "文件号", "专项工程", "标准文件库类型", "标准文件库类型对应的线下文件目录", "年份", "自定义目录建议", "文件大小", "文件类型",
                "线下文件目录", "工程类型");
        if (dataType.equals("工程项目类")) {
            header = Lists.newArrayList("序号", "文件原名", "文件名", "文件号", "标准文件库类型", "标准文件库类型对应的线下文件目录", "文件大小", "文件类型", "专项工程",
                    "项目名称", "父项目名称", "项目投运年度", "线下文件目录", "工程类型");
        }
        rows.add(header);
        int index = 1;
        for (ItemEntity item : itemEntityList) {
            List<String> row = Lists.newArrayList();
            row.add(index++ + ""); // 序号
            row.add(item.getFileOriginalName());
            row.add(item.getFileName());
//            row.add(item.getDataType());
            row.add(item.getFileNumber());
            // "序号", "文件原名", "文件名", "文件号", "标准文件库类型", "标准文件库类型对应的线下文件目录", "文件大小", "文件类型", "专项工程",
            //                    "项目名称", "父项目名称", "项目投运年度", "线下文件目录"
            if (dataType.equals("工程项目类")) {

                row.add(item.getStandardFileType());
                row.add(item.getStandardFileDirectory());
                row.add(item.getFileSize());
                row.add(item.getFileType());
                row.add(item.getSpecialProject());

                row.add(item.getProjectName());
                row.add(item.getParentProjectName());
                row.add(item.getProjectYear());
            } else if (!dataType.equals("工程项目类")) {
                // "序号", "文件原名", "文件名", "文件号", "专项工程", "标准文件库类型", "标准文件库类型对应的线下文件目录", "年份", "自定义目录建议", "文件大小", "文件类型",
                //                "线下文件目录"
                row.add(item.getSpecialProject());
                row.add(item.getStandardFileType());
                row.add(item.getStandardFileDirectory());

                row.add(item.getYear());
                row.add(item.getCustomDirectorySuggestion());
                row.add(item.getFileSize());
                row.add(item.getFileType());
            }
            row.add(item.getOfflineFileDirectory());
            row.add(item.getDataType());
            rows.add(row);
        }
        // 写入 Excel 文件
        String outputFilePath = "F:/公司3/out/" + specialProject + "_" + dataType + "_" + System.currentTimeMillis() + ".xlsx"; // 输出文件路径
        ExcelWriter writer = ExcelUtil.getWriter(outputFilePath)
                .write(rows, true);
        writer.getCellStyle().setWrapText(true); // 设置单元格文本换行
        // 设置列宽
        for (int i = 1; i < header.size(); i++) {
            writer.setColumnWidth(i, 30); // 设置每列宽度为20
        }
        //关闭writer，释放内存
        writer.close();
    }

    // 区域判断
    public static String checkByArea(String fileName, String flowName, List<String> lineAreaList) {
        if (StringUtils.isEmpty(fileName)) {
            return "";
        }
        if (CollectionUtils.isEmpty(lineAreaList)) {
            return "";
        }

        List<String> areaByFlowName = getAreaByFlowName(fileName);// 提取括号内的内容
        if (CollectionUtils.isEmpty(areaByFlowName)) {
            return flowName;
        }

        for (String area : areaByFlowName) {
            boolean flag = false;
            for (String lineArea : lineAreaList) {
                if (area.contains(lineArea)) {
                    flag = true;
                    break;
                }
            }
            if (flag) {
                return flowName; // 返回匹配的地区
            }
        }
        return "-";
    }

    // 获取文件名中的地区信息
    public static List<String> getAreaByFlowName(String name) {

        if (StringUtils.isNotEmpty(name) && !name.contains("（") && !name.contains("）") && !name.contains("(") && !name.contains(")")) {
            // 如果文件名中包含括号，则提取括号内的内容
            return Lists.newArrayList();
        }
        if (StringUtils.isEmpty(name)) {
            return Lists.newArrayList();
        }

        name = name.replace("(", "（").replace(")", "）"); // 替换英文括号为中文括号

        String regex = "（([^)]+)）"; // 小括号正则表达式
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(name);

        List<String> list = Lists.newArrayList();
        while (matcher.find()) {
            list.add(matcher.group(1));
        }
        return list;
    }

    public static String getYearByFlowName(String name) {
        String regex = "20\\d{2}"; // 小括号正则表达式
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(name);

        if (matcher.find()) {
            return matcher.group();
        }
        return null;
    }

    // 项目信息表
    public static List<ProjectEntity> getProjectEntityList(String excelPath) {
        List<List<Object>> listList = ExcelUtil.getReader(new File(excelPath), "表3-2 投资明细表").read(5, 80);

        List<ProjectEntity> projectEntities = new ArrayList<>();
        for (List<Object> row : listList) {
            ProjectEntity projectEntity = new ProjectEntity();
            projectEntity.setDataSource(String.valueOf(row.get(2))); // 数据来源
            projectEntity.setCommissioningDate(String.valueOf(row.get(3))); // 投产日期
            projectEntity.setProjectName(String.valueOf(row.get(7))); // 项目名称

            // 投产年份
            projectEntity.setCommissioningDate(projectEntity.getCommissioningDate().split("年")[0]);
            if (StringUtils.isNotEmpty(projectEntity.getDataSource())) {
                projectEntities.add(projectEntity);
            }
        }
        return projectEntities;
//        return projectEntities.stream().collect(Collectors.groupingBy(ProjectEntity::getDataSource));
    }

    // 祛除序号
    public static String removeStrNumberAndPoint(String str) {
        // 使用正则表达式分割字符串
        String[] parts = str.split("/");
        // 创建一个 StringBuilder 来存储结果
        StringBuilder result = new StringBuilder();

        // 遍历每个部分，去除序号
        for (String part : parts) {
            // 去除序号
            String cleanedPart = part.replaceAll("^\\d+\\.\\s*", "");
            cleanedPart = cleanedPart.replaceAll("^\\d+、\\s*", "");
            cleanedPart = cleanedPart.replaceAll("^\\d+-\\s*", "");
            // 将处理后的部分添加到结果中
            result.append(cleanedPart).append("/");
        }
        // 去掉最后一个多余的斜杠
        if (result.length() > 0) {
            result.setLength(result.length() - 1);
        }
        return result.toString().trim();
    }

    // 祛除字符中的特殊字符
    public static String removeSpecialCharacters(String txt) {
        if (StringUtils.isEmpty(txt)) {
            return txt;
        }
        if (txt.startsWith("-")) {
            txt = txt.substring(1).trim(); // 去掉开头的负号和空格
        }
        if (txt.startsWith("~$")) {
            txt = txt.substring(2).trim();
        }
        return txt.trim();
    }

    public static String getText(String text) {
        String regex = "国网(.*?)电力部分";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);
        if (matcher.find()) {
            // 获取匹配的数字部分
            String day = matcher.group(1);
            // 构造结果字符串
            return "国网" + day;
        }
        return "";
    }
}
